/*
 * eConf.java
 *
 * Created on 11 juil. 2011, 18:13:43
 */
/**
 *
 * @author jannoned
 */
/*
Dominique Jannone
Guillaume Marre
Yohan Ojeda
Laurent Schiavon
*/
package model;


import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.io.ObjectInputStream.GetField;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.logging.LogManager;
import java.util.logging.Logger;
import java.util.logging.Level;

import javax.media.CaptureDeviceInfo;
import javax.media.Processor;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.text.html.HTMLDocument.HTMLReader.IsindexAction;

import org.ietf.jgss.Oid;

import controleur.CanalUpdateVueConf;
import controleur.Constantes;
import vue.Fenetre;
import vue.PanneauBody;

public class eConf {
	
	

	static // Attributs
	Fenetre fenetre;
	private static int port_Serveur, portEmetteurDuServeur;
	private static String ip_Serveur;
	private static ObjectOutputStream oos;
	private static ObjectInputStream ois;
	Constantes constante;
	private UserClientDelegate ucd;
	private Conference conference;
	private static String roleUserConferenceActuel;
	private static String idConferenceActuel, dnUtilisateur;
	private static boolean clientIsOn;
	private static boolean conferenceOnAir;
	private static String idConfActuelle;
	private static CaptureDeviceInfo di;
	private static Processor FichierCessor;
	
	final static String FICHIER_CONFIGURATION_LOG = "/LOG_client.properties";
	public static final Logger logger = Logger.getLogger(eConf.class.getName());



	// Observateur
	public UserClientDelegate getUcd() {return ucd;}
	public static String getRoleUserConferenceActuel() {
		return roleUserConferenceActuel;
	}
	public static String getIdConferenceActuel() {
		return idConferenceActuel;
	}
	public static String getIdConfActuelle() {
		return idConfActuelle;
	}
	public static String getDnUtilisateur() {
		return dnUtilisateur;
	}
	public static int getPortEmetteurDuServeur() {
		return portEmetteurDuServeur;
	}
	public static void setPortEmetteurDuServeur(int portEmetteurDuServeur) {
		eConf.portEmetteurDuServeur = portEmetteurDuServeur;
	}
	public static void setDnUtilisateur(String dnUtilisateur) {
		eConf.dnUtilisateur = dnUtilisateur;
	}
	public static void setIdConfActuelle(String idConfActuelle) {
		eConf.idConfActuelle = idConfActuelle;
	}
	public static boolean isClientIsOn() {
		return clientIsOn;
	}
	public static boolean isConferenceOnAir() {
		return conferenceOnAir;
	}
	public Conference getConference() {
		return conference;
	}
	public static String getIp_Serveur() {
		return ip_Serveur;
	}
	
	public static CaptureDeviceInfo getDi() {
		return di;
	}

	public static Processor getFichierCessor() {
		return FichierCessor;
	}
	
	// Mutateur
	public static void setRoleUserConferenceActuel(String roleUserConferenceActuel) {
		eConf.roleUserConferenceActuel = roleUserConferenceActuel;
	}
	public static void setIdConferenceActuel(String idConferenceActuel) {
		eConf.idConferenceActuel = idConferenceActuel;
	}
	public static void setClientIsOn(boolean clientIsOn) {
		eConf.clientIsOn = clientIsOn;
	}
	public static void setConferenceOnAir(boolean conferenceOnAir) {
		eConf.conferenceOnAir = conferenceOnAir;
	}
	public void setConference(Conference conference) {
		this.conference = conference;
	}
	
	public static void setDi(CaptureDeviceInfo di) {
		eConf.di = di;
	}
	
	public static void setFichierCessor(Processor fichierCessor) {
		FichierCessor = fichierCessor;
	}
	
	// Constructeur
	public eConf() {
		clientIsOn = true;
		fenetre = new Fenetre(this);
		ucd = new UserClientDelegate(ip_Serveur, port_Serveur, fenetre);
		// Lancement du recepteur
		conference = new Conference(this, ip_Serveur);
		//Ecoute sur le port 2222 pour la MAJ de la vue durant les conférences
		CanalUpdateVueConf canalMajVueConf = new CanalUpdateVueConf(fenetre, this);
		canalMajVueConf.start();
		conference.start();
	}
	

	// MAIN
	public static void main(String[] args) {
		   // get arg 
		   port_Serveur = Integer.parseInt(args[1]);
		   ip_Serveur = args[0];
		   
		// Chargement du fichier de configuration des logs

			final InputStream inputStream = eConf.class.getResourceAsStream(FICHIER_CONFIGURATION_LOG);
				try
				{
			    LogManager.getLogManager().readConfiguration(inputStream);
				}
				catch (final IOException e)
				{
				    Logger.getAnonymousLogger().severe("Le fichier de configuration de log: " +FICHIER_CONFIGURATION_LOG +" n'a pas pu être chargé");
				    Logger.getAnonymousLogger().severe(e.getMessage());
				 	
				}
		 
		   // Lancement du serveur
		   new eConf();
		}
	
	// Methode de mise à jour
	public static void requeteServerMenu(int etat){
		// Envoie au serveur la demande de changement d'etat
			/// ...............
		// Recoie la réponse du Serveur
			// ....
	}
	
	// Methode demande de fermeture du programme
	public static void closeEConf(){
		clientIsOn = false;
		fenetre.dispose();
		System.exit(0);
	}
	
	//Methode get date time
	public Date dateTimeActuelle() {
        Date date = new Date();
        return date;
    }
	  
	  // Méthode qui permet d'envoyer un tableau au serveur
	public static boolean EnvoiInfoAuServeur(Object[] value) 
	{			 
			  // On se connecte au ServerSocket du serveur
			    try {
			    	 logger.log(Level.INFO," ---> Envoi des infos en cours au serveur sur le port " + port_Serveur);
				      OutputStream sortie = UserClientDelegate.socket.getOutputStream();
					  ObjectOutputStream oos = new ObjectOutputStream(sortie);
					  
					  //Envoi du tableau vers le serveur
					  for (int i = 0; i < value.length; i++) {
						    Object element = value[i];
						    logger.log(Level.INFO,"Les données à envoyer sont : " + element);						       
							oos.writeObject(element);
							oos.flush();
						}
				    } catch (Exception e2) {
				    	logger.log(Level.SEVERE," ---> Erreur en creant le flux de sortie");
				    	logger.log(Level.SEVERE,e2.getClass() + ": " +  e2.getMessage(), e2);
			      return false;
			    }
		return true;
	}
	
	  // Méthode qui permet d'envoyer un tableau à  2 dimensions au serveur
		public static boolean EnvoiInfoAuServeur2D(Object[][] value) 
		{
				    try {
				  // Creation du flux de sortie
					      OutputStream fluxsortie2D = UserClientDelegate.socket.getOutputStream();
					      logger.log(Level.INFO," ---> Envoi des infos en cours au serveur sur le port " + port_Serveur +"...");
					      OutputStream sortie = UserClientDelegate.socket.getOutputStream();
						  ObjectOutputStream oos = new ObjectOutputStream(sortie);
						  
						  //Envoi du tableau vers le serveur
						  for (int i = 0; i < value.length; i++) {
							  for (int j = 0; j < value.length; j++) {
							    Object element = value[i][j];
							    logger.log(Level.INFO,"Les données a envoyees sont : " + element +"\n");						       
								oos.writeObject(element);
								oos.flush();
							}
						  }			   
					    } catch (Exception e2) {
					  logger.log(Level.SEVERE," ---> Erreur en creant le flux de sortie : ");
				      logger.log(Level.SEVERE,e2.getClass() + ": " +  e2.getMessage(), e2);
				      return false;
				    }
			return true;
		}
		
		public static Object[] ReceptionObjetFromClient() {
			//Déclaration des variables
			Object[] valueTab = new Object[8];

				 try {			   
				   // Reception du tableau
				   InputStream is = UserClientDelegate.socket.getInputStream();
				   ObjectInputStream ois = new ObjectInputStream(is);
	
				   //Parcours (lecture) du tableau reçu
				   for (int i = 0; i < 8; i++) {
					   Object value = ois.readObject();
					   valueTab[i] = value;
					   logger.log(Level.INFO,"Données dans le tableau :" + valueTab);
					}
				   //Affichage des données reçues
				   logger.log(Level.INFO,"Données à la ligne 0 : " + valueTab[0]);
				 }catch (Exception e) {
					 logger.log(Level.SEVERE," ---> Erreur en creant le flux de sortie : " + e);
				 logger.log(Level.SEVERE,e.getClass() + ": " +  e.getMessage(), e);}
			return valueTab;
			}
		
		
		   //Méthode qui permet de recevoir un tableau d'objet de x lignes (x étant envoyé par un ack avant le tableau lui même)
		
	     public static Object[] ReceptionObjet1DFromServer() {
	     
	    	 Object[] valueRepTabNbLigne = new Object[2];
	    	 Object[] tabDonneesUtilisateur = null;
	    	 
			 try {			   
			   // Reception du tableau
			   InputStream is = UserClientDelegate.socket.getInputStream();
			   ObjectInputStream ois = new ObjectInputStream(is);

			   //Parcours (lecture) du tableau reçu
			   for (int i = 0; i < 2; i++) {
				   Object valueReponse = ois.readObject();
				   valueRepTabNbLigne[i] = valueReponse;
//				   System.out.println("Réponse du serveur:" +valueRepTabNbLigne[i]);
				}
			   
			   int nbLignes = new Integer(valueRepTabNbLigne[1].toString());
			   
			   tabDonneesUtilisateur = new Object[nbLignes];
			   
			   //Parcours (lecture) du tableau reçu
		         for (int i = 0; i < nbLignes; i++) {
		      		 Object valueRead = ois.readObject();
		      		tabDonneesUtilisateur[i] = valueRead;
		      		logger.log(Level.INFO,"Données dans le tableau des données utilisateurs :" + valueRead);
		         }
			 }catch (Exception e) {
				 logger.log(Level.SEVERE," ---> Erreur en creant le flux de sortie : " + e.getStackTrace());
			 logger.log(Level.SEVERE,e.getClass() + ": " +  e.getMessage(), e);
			 }
		return tabDonneesUtilisateur;
	      }
	     
	     

		public boolean EnvoiDemandeAuServeur(int ID, String description) {
			// On se connecte au ServerSocket du serveur
			logger.log(Level.INFO,"ID: "+ID);
		    try {
		    	
			      OutputStream sortie = UserClientDelegate.socket.getOutputStream();
				  ObjectOutputStream oos = new ObjectOutputStream(sortie);
					    //Envoie de l'ID
				  logger.log(Level.INFO,"after ID: "+ID);		
				  		Object elementID = ID;
				  		logger.log(Level.INFO,"elementID: "+elementID);
				  		logger.log(Level.INFO,"Les données a envoyees sont : " + elementID);						       
						oos.writeObject(elementID);
						oos.flush();
						//Envoie de la description
						Object elementDescitpion = description;
						logger.log(Level.INFO,"Les données a envoyees sont : " + elementDescitpion);						       
						oos.writeObject(elementDescitpion);
						oos.flush();
			    } catch (Exception e2) {
			  logger.log(Level.SEVERE," ---> Erreur en creant le flux de sortie : ");
		      logger.log(Level.SEVERE,e2.getClass() + ": " +  e2.getMessage(), e2);
		      return false;
		    }
	return true;
			
		}
		
//		public boolean EnvoiACKAuServeur(int ID, String description) {
//			// On se connecte au ServerSocket du serveur
//			System.out.println("ID: "+ID);
//		    try {
//		    	
//			      OutputStream sortie = UserClientDelegate.socket.getOutputStream();
//				  ObjectOutputStream oos = new ObjectOutputStream(sortie);
//				  				  
//					    //Envoie de l'ID
//				  		System.out.println("after ID: "+ID);		
//				  		Object elementID = ID;
//				  		System.out.println("elementID: "+elementID);
//					    System.out.println("Les données a envoyees sont : " + elementID);						       
//						oos.writeObject(elementID);
//						oos.flush();
//						//Envoie de la description
//						Object elementDescitpion = description;
//					    System.out.println("Les données a envoyees sont : " + elementDescitpion);						       
//						oos.writeObject(elementDescitpion);
//						oos.flush();
//			    } catch (Exception e2) {
//		      System.out.println(" ---> Erreur en creant le flux de sortie : " + e2);
//		      return false;
//		    }
//	return true;
//			
//		}
		public boolean EnvoiACKAuServeur(int ID, String description) {
			// On se connecte au ServerSocket du serveur
			logger.log(Level.INFO,"ID: "+ID);
			
		    try {
			      OutputStream sortie = ucd.socket.getOutputStream();
				  ObjectOutputStream oos = new ObjectOutputStream(sortie);
				  
				  
					    //Envoie de l'ID
				  logger.log(Level.INFO,"after ID: "+ID);		
				  		Object elementID = ID;
				  		logger.log(Level.INFO,"elementID: "+elementID);
				  		logger.log(Level.INFO,"Les données a envoyees sont : " + elementID);						       
						oos.writeObject(elementID);
						oos.flush();
						//Envoie de la description
						Object elementDescitpion = description;
						logger.log(Level.INFO,"Les données a envoyees sont : " + elementDescitpion);						       
						oos.writeObject(elementDescitpion);
						oos.flush();
			    } catch (Exception e2) {
			   logger.log(Level.SEVERE," ---> Erreur en creant le flux de sortie :");
		      logger.log(Level.SEVERE,e2.getClass() + ": " +  e2.getMessage(), e2);
		      return false;
		    }
	return true;
			
		}
		
		 //Méthode qui permet de recevoir le tableau d'objet à 2 dimensions depuis le client
	     public static Object[][] ReceptionObjet2DFromClient(int tLigne, int tColonne) 
	     {
//	    	System.out.println("ReceptionObjet2DFromClient > methode");
	      //Déclaration des variables
	      Object[][] value = new Object[tLigne][tColonne];
	      
	       try {
	         
	         // Reception du tableau
	         InputStream is = UserClientDelegate.socket.getInputStream();
	         ObjectInputStream ois = new ObjectInputStream(is);

	         //Parcours (lecture) du tableau reçu
		         for (int i = 0; i < tLigne; i++) {
		      	   for (int j = 0; j < tColonne; j++) {
//		      	   value = (Object[][]) ois.readObject();
		      		 Object valueRead = ois.readObject();
		      	   value[i][j] = valueRead;
		      	 logger.log(Level.INFO,"Données dans le tableau :" + valueRead);
		      	   }
		         }
	       }catch (Exception e) {
	    	   logger.log(Level.SEVERE," ---> Erreur en creant le flux de sortie : ");
	       logger.log(Level.SEVERE,e.getClass() + ": " +  e.getMessage(), e);}
		return value;
	      }
	     
	   //Méthode qui permet de recevoir le tableau d'objet à 2 dimensions depuis le client pour rejoindre conf SEULEMENT
	     public static Object[][] ReceptionObjet2DPourRejoindreConferenceFromClient() 
	     {
	    	 Object[] valueRepTab = new Object[2];
	    	 Object[][] value = null;
	    	 
			 try {			   
			   // Reception du tableau
			   InputStream is = UserClientDelegate.socket.getInputStream();
			   ObjectInputStream ois = new ObjectInputStream(is);
			   
			   logger.log(Level.INFO,">>>>>>>>>>>  ois.available() :" + ois.available());

			   //Parcours (lecture) du tableau reçu
			   for (int i = 0; i < 2; i++) {
				   Object valueReponse = ois.readObject();
				   valueRepTab[i] = valueReponse;
				   logger.log(Level.INFO,"Réponse du serveur");
				}
			   
			   int nbLignes = new Integer(valueRepTab[1].toString());
			   
			   value = new Object[nbLignes][3];
			   
			   //Parcours (lecture) du tableau reçu
		         for (int i = 0; i < nbLignes; i++) {
		      	   for (int j = 0; j < 3; j++) {
//		      	   value = (Object[][]) ois.readObject();
		      		 Object valueRead = ois.readObject();
		      	   value[i][j] = valueRead;
		      	 logger.log(Level.INFO,"Données dans le tableau :" + valueRead);
		      	   }
		         }
			   
			   
			 }catch (Exception e) {
				 logger.log(Level.SEVERE," ---> Erreur en creant le flux de sortie : " + e.getStackTrace());
			 logger.log(Level.SEVERE,e.getClass() + ": " +  e.getMessage(), e);
			 }
	
		return value;
	      }
	   
	   
	   //Méthode qui permet de recevoir le tableau d'objet à 2 dimensions depuis le client pour les conférences SEULEMENT
	     public static Object[][] ReceptionObjet2DPourConferenceFromClient() 
	     {
	    	 Object[] valueRepTab = new Object[2];
	    	 Object[][] value = null;
	    	 
			 try {			   
			   // Reception du tableau
			   InputStream is = UserClientDelegate.socket.getInputStream();
			   ObjectInputStream ois = new ObjectInputStream(is);

			   //Parcours (lecture) du tableau reçu
			   for (int i = 0; i < 2; i++) {
				   Object valueReponse = ois.readObject();
				   valueRepTab[i] = valueReponse;
				   logger.log(Level.INFO,"Réponse du serveur");
				}
			   
			   int nbLignes = new Integer(valueRepTab[1].toString());
			   
			   value = new Object[nbLignes][8];
			   
			   //Parcours (lecture) du tableau reçu
		         for (int i = 0; i < nbLignes; i++) {
		      	   for (int j = 0; j < 8; j++) {
//		      	   value = (Object[][]) ois.readObject();
		      		 Object valueRead = ois.readObject();
		      	   value[i][j] = valueRead;
		      	   //System.out.println("Données dans le tableau :" + valueRead);
		      	   }
		         }
			   
			   
			 }catch (Exception e) {
			 logger.log(Level.SEVERE," ---> Erreur en creant le flux de sortie : " + e.getStackTrace());
			 logger.log(Level.SEVERE,e.getClass() + ": " +  e.getMessage(), e);
			 }
	
		return value;
	      }
	     
		   //Méthode qui permet de recevoir le tableau d'objet à 2 dimensions depuis le client pour la demande de profile SEULEMENT
	     public static Object[][] ReceptionObjet2DPourDemandeProfileFromClient() 
	     {
	    	 Object[] valueRepTab = new Object[2];
	    	 Object[][] value = null;
	    	 
			 try {			   
			   // Reception du tableau
			   InputStream is = UserClientDelegate.socket.getInputStream();
			   ObjectInputStream ois = new ObjectInputStream(is);

			   //Parcours (lecture) du tableau reçu
			   for (int i = 0; i < 2; i++) {
				   Object valueReponse = ois.readObject();
				   valueRepTab[i] = valueReponse;
				   logger.log(Level.INFO,"Réponse du serveur");
				}
			   
			   int nbLignes = new Integer(valueRepTab[1].toString());
			   
			   value = new Object[nbLignes][4];
			   
			   //Parcours (lecture) du tableau reçu
		         for (int i = 0; i < nbLignes; i++) {
		      	   for (int j = 0; j < 4; j++) {
//		      	   value = (Object[][]) ois.readObject();
		      		 Object valueRead = ois.readObject();
		      		 logger.log(Level.INFO,"Réponse du serveur: "+valueRead);
		      	   value[i][j] = valueRead;
		      	   //System.out.println("Données dans le tableau :" + valueRead);
		      	   }
		         }
			   
			   
			 }catch (Exception e) {
				 logger.log(Level.SEVERE," ---> Erreur en creant le flux de sortie : ");
			 logger.log(Level.SEVERE,e.getClass() + ": " +  e.getMessage(), e);
			 }
	
		return value;
	      }
	         
	     
	     
	   //Modification YO - Monitoring
			///////////////////////////////
			///////////////////////////////
			///////////////////////////////
			public static Object[][] ReceptionObjet2DFromClientSupervision() 
		     {
//		    	System.out.println("ReceptionObjet2DFromClientSupervision > methode supervision");
		      //Déclaration des variables
		      Object[][] value = new Object[23][2];
		      
		       try {
		         
		         // Reception du tableau
		         InputStream is = UserClientDelegate.socket.getInputStream();
		         ObjectInputStream ois = new ObjectInputStream(is);

		         //Parcours (lecture) du tableau reçu
			         for (int i = 0; i < 23; i++) {
			      	   for (int j = 0; j < 2; j++) {
			      		 Object valueRead = ois.readObject();
			      	   value[i][j] = valueRead;
			      	 logger.log(Level.INFO,"Données dans le tableau  ["+i+"]["+j+"]:" + valueRead);
			      	   }
			         }
			         
			        
		       }catch (Exception e) {
		    	   logger.log(Level.SEVERE," ---> Erreur en creant le flux de sortie : ");
					 logger.log(Level.SEVERE,e.getClass() + ": " +  e.getMessage(), e);
					 }
			return value;
		      }
			///////////////////////////////
			///////////////////////////////
			///////////////////////////////
			// Fin de modification YO - Monitoring
	     
	     
	     //A VOIR
	   //Méthode qui permet de recevoir la liste des personnes d'une conférence lorsque l'on rejoint une conférence
	     public static Object[][] ReceptionObjetRejoindreConference(int tLigne, int tColonne) 
	     {
	    	 logger.log(Level.INFO,"ReceptionObjet2DFromClient > methode");
	      //Déclaration des variables
	      Object[][] value = new Object[6][3];
	      
	       try {
	         // Reception du tableau
	         InputStream is = UserClientDelegate.socket.getInputStream();
	         ObjectInputStream ois = new ObjectInputStream(is);
	         
	      	 value[0][0] = (String) ois.readObject();
	      	 value[0][1] = (Integer) ois.readObject();
	      	 value[0][2] = (String) ois.readObject();
	      	 value[1][0] = (String) ois.readObject();
	      	 value[1][1] = (Integer) ois.readObject();
	      	 value[1][2] = (String) ois.readObject();
	      	 value[2][0] = (String) ois.readObject();
	      	 value[2][1] = (Integer) ois.readObject();
	      	 value[2][2] = (String) ois.readObject();
	      	 value[3][0] = (String) ois.readObject();
	      	 value[3][1] = (Integer) ois.readObject();
	      	 value[3][2] = (String) ois.readObject();
	      	 value[4][0] = (String) ois.readObject();
	      	 value[4][1] = (Integer) ois.readObject();
	      	 value[4][2] = (String) ois.readObject();
	      	 value[5][0] = (String) ois.readObject();
	      	 value[5][1] = (Integer) ois.readObject();
	      	 value[5][2] = (String) ois.readObject();

	       }catch (Exception e) {
	    	   logger.log(Level.SEVERE," ---> Erreur en creant le flux de sortie : ");
				 logger.log(Level.SEVERE,e.getClass() + ": " +  e.getMessage(), e);
	       }
		return value;
	      }
		
		public static Object[] RecoiReponseDuServeur() {
			//Déclaration des variables
			Object[] valueRepTab = new Object[2];
				 try {			   
				   // Reception du tableau
				   InputStream is = UserClientDelegate.socket.getInputStream();
				   ObjectInputStream ois = new ObjectInputStream(is);
	
				   //Parcours (lecture) du tableau reçu
				   for (int i = 0; i < 2; i++) {
					   Object valueReponse = ois.readObject();
					   valueRepTab[i] = valueReponse;
					   logger.log(Level.INFO,"Réponse du serveur: "+valueReponse.toString());
					}
				   return valueRepTab;
				 }catch (Exception e) {
					 logger.log(Level.SEVERE," ---> Erreur en creant le flux de sortie : ");
					 logger.log(Level.SEVERE,e.getClass() + ": " +  e.getMessage(), e);
				 valueRepTab[0] = null;
				 valueRepTab[1] = null;
				 return valueRepTab;
				 }
				 
				
			}
		
		// Méthode qui permet de demander une liste au serveur
		public boolean getList(int ID, int NOM_LISTE) {
			// On se connecte au ServerSocket du serveur
			logger.log(Level.INFO,"ID: "+ ID);
		    try {
			      OutputStream sortie = UserClientDelegate.socket.getOutputStream();
				  ObjectOutputStream oos = new ObjectOutputStream(sortie);
					    //Envoie de l'ID
				  logger.log(Level.INFO,"after ID: "+ ID);		
				  		Object elementID = ID;
				  		logger.log(Level.INFO,"elementID: "+elementID);
				  		logger.log(Level.INFO,"Les données a envoyees sont : " + elementID);						       
						oos.writeObject(elementID);
						oos.flush();
						//Envoie du numéro de la liste demandée 
						Object elementNomListe = NOM_LISTE;
						logger.log(Level.INFO,"Les données a envoyees sont : " + elementNomListe);						       
						oos.writeObject(elementNomListe);
						oos.flush();
			    } catch (Exception e2) {
			    	 logger.log(Level.SEVERE," ---> Erreur en creant le flux de sortie : ");
					 logger.log(Level.SEVERE,e2.getClass() + ": " +  e2.getMessage(), e2);
		      return false;
		    }
	return true;
			
		}



		public static Fenetre getFenetre() {
			return fenetre;
		}

		
		// Methode update conference
//		public void updateIHMConf(int idConf, String  roleUser){
//			
//			Object[][] tabReceiveRejoindreConf = ReceptionObjet2DPourRejoindreConferenceFromClient();
//			// Vu sur les conférences
//				// Determine le role de l'utilisateur pour la conf
////				String roleUser = fenetre.getRoleUser(idConf);
//					System.out.println(">>>"+idConf);
//				// Changement de visibilité des boutons du Menu
//					//...
//				// Affiche la vue selon le role de l'utilisateur
//					fenetre.afficheBodyVuConference(roleUser, tabReceiveRejoindreConf);
//		}
	}

